<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1"/>
    <title>向钊君的博客</title>
    <link href="../css/index.css" rel="stylesheet" />
</head>
<body>
  <div class="index">
    <div class="index_title">
      <p class="title_left">
          欢迎来到向钊君的博客
      </p>
      <ul class="title_right">
        <li>
            <a href="">
                前端
              </a>
        </li>
        <li>
            <a href="">
                羊毛
              </a>
        </li>
        <li>
            <a href="">
                关于我们
              </a>
        </li>
      </ul>
    </div>
    <div class="index_content">
      <ul>
          <li>
            <a href="../index.html">
              2018.8.30
            </a>
          </li>
          <li>
              <a href="one.html">
                2018.6.11
              </a>
          </li>
          <li>
              <a href="two.html">
                2018.3.1
              </a>
          </li>
        
      </ul>
      <div class="index_content_right">
          <h2>#new</h2>
          <p>
              新生成了一个对象<br>
              链接到原型<br>
              绑定 this<br>
              返回新对象<br>
              在调用 new 的过程中会发生以上四件事情，我们也可以试着来自己实现一个 new<br>
              
              function create() {<br>
                  // 创建一个空的对象<br>
                  let obj = new Object()<br>
                  // 获得构造函数<br>
                  let Con = [].shift.call(arguments)<br>
                  // 链接到原型<br>
                  obj.__proto__ = Con.prototype<br>
                  // 绑定 this，执行构造函数<br>
                  let result = Con.apply(obj, arguments)<br>
                  // 确保 new 出来的是个对象<br>
                  return typeof result === 'object' ? result : obj<br>
              }<br>
              对于实例对象来说，都是通过 new 产生的，无论是 function Foo() 还是 let a = { b : 1 } 。<br>
              
              对于创建一个对象来说，更推荐使用字面量的方式创建对象（无论性能上还是可读性）。因为你使用 new Object() 的方式创建对象需要通过作用域链一层层找到 Object，但是你使用字面量的方式就没这个问题。<br>
              
              function Foo() {}<br>
              // function 就是个语法糖<br>
              // 内部等同于 new Function()<br>
              let a = { b: 1 }<br>
              // 这个字面量内部也是使用了 new Object()<br>
              对于 new 来说，还需要注意下运算符优先级。<br>
              
              function Foo() {<br>
                  return this;<br>
              }<br>
              Foo.getName = function () {<br>
                  console.log('1');<br>
              };<br>
              Foo.prototype.getName = function () {<br>
                  console.log('2');<br>
              };<br>
              
              new Foo.getName();   // -> 1<br>
              new Foo().getName(); // -> 2     <br>  
              
              
              从上图可以看出，new Foo() 的优先级大于 new Foo ，所以对于上述代码来说可以这样划分执行顺序<br>
              
              new (Foo.getName());   <br>
              (new Foo()).getName();<br>
              对于第一个函数来说，先执行了 Foo.getName() ，所以结果为 1；对于后者来说，先执行 new Foo() 产生了一个实例，然后通过原型链找到了 Foo 上的 getName 函数，所以结果为 2。<br>
          </p>
          <h2>#四则运算符</h2>
          <p>
              只有当加法运算时，其中一方是字符串类型，就会把另一个也转为字符串类型。其他运算只要其中一方是数字，那么另一方就转为数字。并且加法运算会触发三种类型转换：将值转换为原始值，转换为数字，转换为字符串。<br>

              1 + '1' // '11'<br>
              2 * '2' // 4<br>
              [1, 2] + [2, 1] // '1,22,1'<br>
              // [1, 2].toString() -> '1,2'<br>
              // [2, 1].toString() -> '2,1'<br>
              // '1,2' + '2,1' = '1,22,1'<br>
              对于加号需要注意这个表达式 'a' + + 'b'<br>

              'a' + + 'b' // -> "aNaN"<br>
              // 因为 + 'b' -> NaN<br>
              // 你也许在一些代码中看到过 + '1' -> 1<br>
          </p>

      </div>
    </div>
      
  </div>

  <script>
    
  </script>
</body>
</html>